/**
 * File Name: Stroming.java
 *
 * Date: 18/12/2009
 *
 */
package model;

import gui.Constanten;
import java.awt.Polygon;
import java.awt.Shape;
import java.util.Random;
import java.util.Vector;

/**
 * Stromingsgebied die de verplaatsing van de dieren in dit gebied zal beïnvloeden.
 * Elke stroming bestaat uit een sterkte en een richting.
 *
 * @author Michiel Declercq
 * @author Stijn Delbeke
 * @author Dieter Deriemaeker
 * @author Gregory Nickmans
 *
 */
public class Stroming {

    /**
     * Vector met alle stromingsgebieden
     */
    private static Vector<Stroming> flowAreas = new Vector<Stroming>();

    /**
     * Random generator.
     * Static gemaakt om de getallen zo random mogelijk te genereren.
     */
    private static Random generator = new Random(System.nanoTime());

    /**
     * Maximum aantal verschillende vormen van de stromingsgebieden
     */
    private final int MAX_DIFFERENT = Constanten.MAX_DIFFERENT_FLOW_SHAPES;

    /**
     * Breedte van het applet-venster
     */
    private final int MAX_WIDTH = Constanten.CANVAS_WIDTH;

    /**
     * Hoogte van het applet-venster
     */
    private final int MAX_HEIGHT = Constanten.CANVAS_HEIGHT;

    /**
     * Vorm van het stromingsgebied
     */
    private Shape shape;

    /**
     * Maximum sterkte van de stroming.
     * Deze sterkte moet kleiner zijn dan het minimum van de snelheid van de dieren,
     * zodat elk dier tegen de stroom in kan zwemmen
     */
    private double maxStrength;

    /**
     * Sterkte van de stroming
     */
    private double strength;

    /**
     * Richting van de stroom in graden
     */
    private double theta;

    /**
     * Constructor.
     * Genereert een willekeurig gebied met willekeurige stroomsterkte.
     *
     */
    public Stroming() {

        shape = generateRandomShape();

        strength = Math.random() * (Constanten.MAX_SNELHEID_VIS / 1.5);
        while (strength < 1) {
            strength = Math.random() * (Constanten.MAX_SNELHEID_VIS / 1.5);
        }

        theta = Math.random() * 360;

        flowAreas.add(this);
    }

    /**
     * Geeft de vector met stromingsgebieden terug
     *
     * @return Vector<Stroming> flowAreas
     */
    public static Vector<Stroming> getFlowAreas() {
        return flowAreas;
    }

    /**
     * Geeft de vorm van het stromingsgebied terug
     *
     * @return Shape
     */
    public Shape getShape() {
        return shape;
    }

    /**
     * Geeft de sterkte van de stroming terug
     *
     * @return double
     */
    public double getStrength() {
        return strength;
    }

    /**
     * Geeft de richting (in graden) van de stroming terug
     *
     * @return double
     */
    public double getTheta() {
        return theta;
    }

    /**
     * Genereert een willekeurige vorm waarbinnen de stroming zich zal bevinden
     * @return Shape
     */
    private Shape generateRandomShape() {
        // Coördinaten van de weergeven veelhoeken
        int[] xCoord = new int[MAX_DIFFERENT + 3];
        int[] yCoord = new int[MAX_DIFFERENT + 3];

        // Hoeveel punten er in de veelhoek bevat zijn
        int numPoints;

        numPoints = generator.nextInt(MAX_DIFFERENT) + 3;

        for (int i = 0; i < numPoints; i++) {
            xCoord[i] = generator.nextInt(MAX_WIDTH);
            yCoord[i] = generator.nextInt(MAX_HEIGHT);
        }

        return new Polygon(xCoord, yCoord, numPoints);
    }
}
